import { Context } from "koa";
import dictService from "../service/dict.service";
import { access, sql } from "../logger";
import { callbackData } from "../utils/data.handler";
import { pagination } from "../utils/pagination";

class DictController {
    async createType(ctx: Context) {
        //获取数据
        let { name, code } = ctx.request.body;
        //操作数据库
        try {
            const res = await dictService.createType({ name, code });
            // 返回结果
            access.info('字典创建成功', { name: res.name })
            ctx.body = callbackData('0', '字典创建成功')
        } catch (err) {
            sql.error('字典创建失败', err)
            console.error('字典创建失败', err)
            ctx.app.emit('error', callbackData('3', '字典创建失败'), ctx);
        }
    }
    async updateType(ctx: Context) {
        const { id, name, code } = ctx.request.body;
        if (!id) {
            access.error('请选择更新字典')
            console.error('请选择更新字典')
            ctx.app.emit('error', callbackData('1', '请选择更新字典'), ctx);
            return false;
        }
        // 操作数据库
        try {
            await dictService.updateTypeById({ id, name, code });
            // 返回结果
            access.info('更新字典成功', { name })
            ctx.body = callbackData('0', '更新字典成功')
        } catch (err) {
            sql.error('更新字典失败', err)
            console.error('更新字典失败', err)
            ctx.app.emit('error', callbackData('3', '更新字典失败'), ctx);
        }
    }
    //删除类型
    async deleteType(ctx: Context) {
        let { ids = '' } = JSON.parse(JSON.stringify(ctx.query));
        if (!ids) {
            access.error('请选择删除字典')
            console.error('请选择删除字典')
            ctx.app.emit('error', callbackData('1', '请选择删除字典'), ctx);
            return false;
        }
        try {
            let idBox = ids.split(',');
            await dictService.deleteType(idBox)
            // 返回结果
            sql.info('删除字典成功', { ids })
            ctx.body = callbackData('0', '删除字典成功')
        } catch (err) {
            sql.error('删除字典失败', err)
            console.error('删除字典失败', err)
            ctx.app.emit('error', callbackData('3', '删除字典失败'), ctx);
        }
    }
    async queryTypeList(ctx: Context) {
        //获取数据
        const { id = '', code = '', name = ''} = JSON.parse(JSON.stringify(ctx.query)) || {};
        const { page = 1, size = 10 } = ctx.request.body;
        try {
            const res = await dictService.getTypeList({ id, code, name})
            // 返回结果
            if(res){
                let {count,rows} = res;
                sql.info('查询成功', { name,page, size, code })
                ctx.body = callbackData('0', '查询成功', pagination(rows,page,count,size))
            }else{
                sql.error('字典列表查询失败',{ name,page, size, code })
                console.error('字典列表查询失败', { name,page, size, code })
                ctx.app.emit('error', callbackData('3', '字典列表查询失败'), ctx);
            }
        } catch (err) {
            sql.error('字典列表查询失败', err)
            console.error('字典列表查询失败', err)
            ctx.app.emit('error', callbackData('3', '字典列表查询失败'), ctx);
        }
    }

    async createData(ctx: Context) {
        //获取数据
        let { dict_label,dict_code,dict_value,dict_color} = ctx.request.body;
        //操作数据库
        try {
            const res = await dictService.createData({ dict_label,dict_code,dict_value,dict_color });
            // 返回结果
            access.info('字典值创建成功', { name: res.dict_label })
            ctx.body = callbackData('0', '字典值创建成功')
        } catch (err) {
            sql.error('字典值创建失败', err)
            console.error('字典值创建失败', err)
            ctx.app.emit('error', callbackData('3', '字典值创建失败'), ctx);
        }
    }
    async updateData(ctx: Context) {
        const { id,dict_label,dict_code,dict_value,dict_color } = ctx.request.body;
        if (!id) {
            access.error('请选择更新字典')
            console.error('请选择更新字典')
            ctx.app.emit('error', callbackData('1', '请选择更新字典'), ctx);
            return false;
        }
        // 操作数据库
        try {
            await dictService.updateDataById({ id,dict_label,dict_code,dict_value,dict_color });
            // 返回结果
            access.info('更新字典值成功', { dict_label,dict_code,dict_value })
            ctx.body = callbackData('0', '更新字典值成功')
        } catch (err) {
            sql.error('更新字典值失败', err)
            console.error('更新字典值失败', err)
            ctx.app.emit('error', callbackData('3', '更新字典值失败'), ctx);
        }
    }
    //删除类型
    async deleteData(ctx: Context) {
        let { ids = '' } = JSON.parse(JSON.stringify(ctx.query));
        if (!ids) {
            access.error('请选择删除字典值')
            console.error('请选择删除字典值')
            ctx.app.emit('error', callbackData('1', '请选择删除字典值'), ctx);
            return false;
        }
        try {
            let idBox = ids.split(',');
            idBox.map(async id => {
                await dictService.deleteData(id)
            });
            // 返回结果
            sql.info('删除字典值成功', { ids })
            ctx.body = callbackData('0', '删除字典值成功')
        } catch (err) {
            sql.error('删除字典值失败', err)
            console.error('删除字典值失败', err)
            ctx.app.emit('error', callbackData('3', '删除字典值失败'), ctx);
        }
    }
    async queryDataList(ctx: Context) {
        //获取数据
        const { id = '', dict_label = '', dict_code = '',dict_value,dict_color} = JSON.parse(JSON.stringify(ctx.query)) || {};
        const { page = 1, size = 10 } = ctx.request.body;
        try {
            const res = await dictService.getDataList({ id, dict_label , dict_code ,dict_value,dict_color})
            // 返回结果
            if(res){
                let {count,rows} = res;
                sql.info('查询成功', { page, size, dict_label , dict_code ,dict_value })
                ctx.body = callbackData('0', '查询成功', pagination(rows,page,count,size))
            }else{
                sql.error('字典值列表查询失败',{ page, size, dict_label , dict_code ,dict_value })
                console.error('字典值列表查询失败', { page, size, dict_label , dict_code ,dict_value })
                ctx.app.emit('error', callbackData('3', '字典值列表查询失败'), ctx);
            }
        } catch (err) {
            sql.error('字典值列表查询失败', err)
            console.error('字典值列表查询失败', err)
            ctx.app.emit('error', callbackData('3', '字典值列表查询失败'), ctx);
        }
    }
}

export default new DictController